#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "carte.h"
#include "stockcartetransaction.h"

/**
@brief InitialiserPTabDyn permet d'initialiser le tableau dynamique contenant les cartes que le joueur va pioché, il est initialisé a une alvéole vide
@param [in] t: pointeur sur StockCarte
@return none
*/
void InitialiserTabDynT(StockCarteTransaction * t)
{
    (*t).capacite = 1;
    (*t).ad = malloc(sizeof(CarteTransaction));
    (*t).taille_utilisee = 0;
}

/**
@brief testamentTabDyn permet de libérer la mémoire allouée dynamiquement
@param [in] t: pointeur sur StockCarte
@return none
*/
void TestamentTabDynT(StockCarteTransaction *t)
{
    if((*t).ad!=0)
    {
        free ((*t).ad);
        (*t).ad = 0;
        (*t).capacite = 0;
        (*t).taille_utilisee = 0;
    }
}

/**
@brief tailleUtiliseeTabDyn nombre de Cartes stockes
@param  [in] t: pointeur sur StockCarte
@return entier
*/
int EstVideTabT(StockCarteTransaction *t)
{
    if (t->taille_utilisee==0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

/**
@brief ajouterElementTabDyn permet d'ajouter une carte au tableau est d'incrémenter la taille utilisée par 1 ainsi que de doubler la capacité si nécessaire
@param  [in] t: pointeur sur StockCarte, [in,out] c: Carte
@return none
*/
/* Precondition : t prealablement initialise */
void AjouterElementTabDynT(StockCarteTransaction *t, const CarteTransaction c)
{
    int i;
    if((*t).taille_utilisee ==(*t).capacite)
    {
        CarteTransaction *temp = (*t).ad;
        (*t).ad = malloc(2*(*t).capacite*sizeof(CarteTransaction));
        for(i=0;i< (*t).capacite;i++)
        {
            (*t).ad[i]=temp[i];
        }
        (*t).capacite = 2*(*t).capacite;
        free(temp);
    }
    (*t).ad[(*t).taille_utilisee]=c;
    (*t).taille_utilisee=(*t).taille_utilisee+1;
}

/**
@brief supprimerElementTabDyn permet de supprimer une carte au tableau est de décrementer la taille utilisée par 1 ainsi si tailleUtilisee < capacite/3, alors on divise la capacité par 2.
@param  [in] t: pointeur sur StockCarte, [in, out] position: entier
@return none
*/
/* Precondition : t prealablement initialise et non vide */
void SupprimerElementTabDynT( StockCarteTransaction* t, const int position )
{
   int i;
   CarteTransaction *temp;
   if(position<t->taille_utilisee-1)
   	{
   		for(i=position; i<t->taille_utilisee-1;i++)
   			{
   			t->ad[i]=t->ad[i+1];
   			}
   	}
   t->taille_utilisee --;
   if((*t).taille_utilisee < (*t).capacite/3)
   	{
   	temp=t->ad;
   	t->capacite=t->capacite/2;
   	t->ad=(CarteTransaction*)malloc((t->capacite)*sizeof(CarteTransaction));
   	for(i=0;i<t->taille_utilisee;i++)
   		{
   		t->ad[i]=temp[i];
   		}
   	free(temp);
   	}
}

/**
@brief valeurIemeElementTabDyn retourne la i+1eme Carte de t
@param  [in, out] t: pointeur sur StockCarte, [in] i: entier
@return Carte
*/
/* Precondition : t prealablement initialise, 0 <= i < tailleUtilisee(t) */
CarteTransaction ValeurIemeElementTabDynT(const StockCarteTransaction *t, unsigned int i)
{
    //assert (i<0);
    //assert (i> (*t).taille_utilisee);
    /*if (i>=0 && i< (*t).taille_utilisee)*/
    return (*t).ad[i];
}
